﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;

namespace Proy_Operativos
{
    class FileSystem
    {
        string _path = @"Sample.xml";
        XmlDocument _xmlMemoria = new XmlDocument();
        bool estado = false;
        public XmlNode nuevo = null;
        bool resultado = false; 



        public FileSystem()
        {
            try
            {
                _xmlMemoria.Load(_path);
            }
            catch(Exception ex)
            {
                throw ex;
            }

        }

        /// <summary>
        /// Propósito: Crear un directorio dentro del file systema
        /// </summary>
        /// <param name="nombre">Nombre del directorio</param>
        /// <param name="padre">Directorio dentro del cual se creará el nuevo directorio</param>
        /// <returns></returns>

        public bool mkDir(string nombre, string padre)
        {
            XmlNode _directorio = _xmlMemoria.DocumentElement;
            bool _estado = false;
            string[] _path = padre.Split('/');
            _estado = _crearDirectorio(_directorio, nombre, _path, _estado, 2);

            return _estado;
        }

        /// <summary>
        /// Propósito: Recorrer el xml del file system y crear el nuevo directorio en el directorio acutal.
        /// </summary>
        /// <param name="nodo">Nodo actual</param>
        /// <param name="nombre">Nombre del directorio</param>
        /// <param name="padre">Directorio en el que se creará el nuevo directorio</param>
        /// <param name="estado">estado de la operación</param>
        /// <returns></returns>

        public bool _crearDirectorio(XmlNode nodo, string nombre, string[] path, bool estado, int posicion)
        {
            foreach (XmlNode hijo in nodo.ChildNodes)
            {
                if ((hijo.Attributes[0].Value == path[posicion]))
                {
                    if ((posicion + 1 != path.Length) && (hijo.Name == "dir"))
                    {
                        estado = _crearDirectorio(hijo, nombre, path, estado, posicion + 1);
                        break;
                    }
                    else if ((hijo.Name == "dir") && (posicion + 1 == path.Length))
                    {
                        XmlNode _nuevoDir = _xmlMemoria.CreateNode(XmlNodeType.Element, "dir", null);
                        XmlAttribute _atributo = _xmlMemoria.CreateAttribute("nombre");
                        _atributo.Value = nombre;
                        _nuevoDir.Attributes.Append(_atributo);
                        _nuevoDir.InnerText = "";
                        hijo.AppendChild(_nuevoDir);
                        _xmlMemoria.Save(_path);
                        estado = true;
                        break;
                    }
                    else
                    {
                        estado = false;
                        break;
                    }
                }


            }
            return estado;
        }

        /// <summary>
        /// Propósito: Moverse a otro directorio dentro del directorio actual.
        /// </summary>
        /// <param name="dirActual">Directorio actual</param>
        /// <param name="dir">directorio</param>
        /// <returns></returns>

        public bool cd(string dirActual, string dir)
        {
            bool _estado = false;
            XmlNode _directorio = _xmlMemoria.DocumentElement;
            
            _estado = buscarCD(_directorio, dirActual, dir, _estado);

            return _estado;
        }

        /// <summary>
        /// Propósito: Realizar una busqueda del directorio al que se desea mover.
        /// </summary>
        /// <param name="nodo">Nodo actual</param>
        /// <param name="dirActual">Directorio actual</param>
        /// <param name="dir">Directorio a desplazarce</param>
        /// <returns></returns>

        public bool buscarCD(XmlNode nodo, string dirActual, string dir, bool estado)
        {


            if ((nodo.Name == "dir") && (nodo.Attributes[0].Value == dirActual))
            {
                foreach (XmlNode hijo in nodo.ChildNodes)
                {
                    if ((hijo.Name == "dir") && (hijo.Attributes[0].Value == dir))
                    {
                        estado = true;
                    }
                }
            }
            else
            {
                foreach (XmlNode hijo in nodo.ChildNodes)
                {
                   estado = buscarCD(hijo, dirActual, dir, estado);
                   if (estado)
                       break;
                }
            }

            return estado;                        
        }

        /// <summary>
        /// Propósito: Retroceder en los directorios del file system.
        /// </summary>
        /// <param name="dirActual">Directorio actual</param>
        /// <param name="dir">directorio a retroeder</param>
        /// <returns></returns>

        public string cdRetroceder(string dirActual, string dir)
        {
            string[] _path = dirActual.Split('/');
            List<string> _listaPath = _path.ToList();
            _listaPath.RemoveAt(0);
            string _resultado = "";

            if (dir.Equals("."))
            {
                _listaPath.RemoveAt(_path.Length - 2);

                foreach (string s in _listaPath)
                {
                    _resultado = _resultado + "/" + s;
                }

                return _resultado;
            }
            else
            {
                _listaPath.RemoveAt(_path.Length - 2);

                if (_path[_path.Length - 2] != "root")
                    _listaPath.RemoveAt(_path.Length - 3);

                foreach (string s in _listaPath)
                {
                    _resultado = _resultado + "/" + s;
                }

                return _resultado;
            }
           
        }

        /// <summary>
        /// Propósito: Retroceder un directorio.
        /// </summary>
        /// <param name="nodo">Nodo acutal</param>
        /// <param name="dir">directorio actual</param>
        /// <param name="dirAnterior">directorio anterior</param>
        /// <returns></returns>

        public string retrocederUno(XmlNode nodo, string dir, string dirAnterior, string path)
        {

            foreach (XmlNode hijo in nodo)
            {
                if ((hijo.Name == "dir") && (hijo.Attributes[0].Value == dir))
                {
                    path = path + "/" + nodo.Attributes[0].Value;
                    break;
                }
                else
                {
                    path = path + "/" + dirAnterior;
                    dirAnterior = retrocederUno(hijo, dir, dirAnterior, path);
                    if (dirAnterior != "")
                        break;
                }
            }

            return path;
        }


        public string cdEspecifico(string path)
        {
            XmlNode _directorio = _xmlMemoria.DocumentElement;
            string[] _path = path.Split('/');

            if (_path[1] == "root")
            {
                if (_path[_path.Length - 1] == "root")
                {
                    return path;
                }
                else if (cdDesplazar(_directorio, _path, 2, false))
                {
                    return _path[_path.Length - 1];
                }
                else
                    return "error";
            }
            else
                return "error";
        }

        public bool cdDesplazar(XmlNode nodo, string[] path, int posicion, bool estado)
        {
            foreach (XmlNode hijo in nodo.ChildNodes)
            {
                if ((hijo.Name == "dir") && (hijo.Attributes[0].Value == path[posicion]))
                {
                    if (posicion + 1 != path.Length)
                    {
                        estado = cdDesplazar(hijo, path, posicion + 1,estado);
                        break;
                    }
                    else if (posicion + 1 == path.Length)
                    {
                        estado = true;
                        break;
                    }
                    else
                    {
                        estado = false;
                        break;
                    }
                }
            }
            return estado;
        }

        /// <summary>
        /// Propósito: Desplegar el contenido de un directorio.
        /// </summary>
        /// <param name="path">Ruta del directorio.</param>
        /// <returns>string con el contenido del directorio</returns>

        public string ls(string path)
        {
            XmlNode _directorio = _xmlMemoria.DocumentElement;

            string[] _path = path.Split('/');

            if (_path[1] == "root")
            {
                if (_path[_path.Length - 1] == "root")
                {
                    return lsContenido(_directorio);
                }
                else
                {
                    XmlNode _dir = lsRecorrer(_directorio, _path, 2);
                    if (_path != null)
                    {
                        return lsContenido(_dir);
                    }
                    else
                    {
                        return "error";
                    }
                }
            }


            return "";
        }

        /// <summary>
        /// Propósito: Recorrer el xml en búsqueda del directorio especificado.
        /// </summary>
        /// <param name="nodo">Nodo actual</param>
        /// <param name="path">Ruta del directorio final</param>
        /// <param name="posicion">Posición en la ruta</param>
        /// <returns>Nodo del directorio final</returns>

        public XmlNode lsRecorrer(XmlNode nodo,  string[] path, int posicion)
        {
            foreach (XmlNode hijo in nodo.ChildNodes)
            {
                if ((hijo.Name == "dir") && (hijo.Attributes[0].Value == path[posicion]))
                {
                    if (posicion + 1 != path.Length)
                    {
                        nodo = lsRecorrer(hijo, path, posicion + 1);
                        break;
                    }
                    else if (posicion + 1 == path.Length)
                    {
                        nodo = hijo;
                        break;
                    }
                    else
                    {
                        nodo = null;
                        break;
                    }
                }
            }
            return nodo;
        }

        /// <summary>
        /// Propósito: obtener el contenido de un directorio.
        /// </summary>
        /// <param name="node">Nodo actual</param>
        /// <returns>String con el contenido del directorio actual</returns>

        public string lsContenido(XmlNode node)
        {
            string _resultado = "";

            foreach (XmlNode hijo in node.ChildNodes)
            {
                if (hijo.Name == "dir")
                {
                    _resultado = _resultado + "Directorio: " + hijo.Attributes[0].Value + " ";
                }
                else if (hijo.Name == "file")
                {
                    _resultado = _resultado + "Archivo: " + hijo.Attributes[0].Value + " ";
                }
                else
                {
                    _resultado = "error";
                    break;
                }
            }

            return _resultado;
        }

        /// <summary>
        /// Porpósito: obtener el contenido de una serie de archivos.
        /// </summary>
        /// <param name="paths">string con las rutas de los archivos</param>
        /// <returns>string con el contenido de los archivos</returns>

        public string cat(string paths)
        {
            XmlNode _directorio = _xmlMemoria.DocumentElement;
            string _resultado = "";
            string[] _paths = paths.Split('$');

            foreach (string p in _paths)
            {
                string[] _path = p.Split('/');
                XmlNode _nodo = catRecorrer(_directorio, _path, 2);
                if (_nodo != null)
                    _resultado = _resultado + catContenido(_nodo);
                else
                {
                    _resultado = "error";
                    break;
                }
            }

            return _resultado;
        }

        /// <summary>
        /// Propósito: Recorrer el xml en búsqueda del archivo especificado.
        /// </summary>
        /// <param name="nodo">Nodo actual</param>
        /// <param name="path">Ruta del archivo final</param>
        /// <param name="posicion">Posición en la ruta</param>
        /// <returns>contenido del archivo</returns>

        public XmlNode catRecorrer(XmlNode nodo, string[] path, int posicion)
        {
            foreach (XmlNode hijo in nodo.ChildNodes)
            {
                if ((hijo.Attributes[0].Value == path[posicion]))
                {
                    if ((posicion + 1 != path.Length) && (hijo.Name == "dir"))
                    {
                        nodo = catRecorrer(hijo, path, posicion + 1);
                        break;
                    }
                    else if ((hijo.Name == "file") && (posicion + 1 == path.Length))
                    {
                        nodo = hijo;                            
                        break;
                    }
                    else
                    {
                        nodo = null;
                        break;
                    }
                }
                

            }
            return nodo;
        }


        /// <summary>
        /// Propósito: obtener el contenido de un archivo.
        /// </summary>
        /// <param name="node">Nodo actual</param>
        /// <returns>String con el contenido del archivo</returns>

        public string catContenido(XmlNode node)
        {
            string _resultado = "";

            if (node.Attributes[2].Value != "FEX00")
            {
                _resultado = node.Attributes[0].Value + ": " + node.Attributes[2].Value + "<-----> ";
            }
            else
            {
                _resultado = node.Attributes[0].Value + ": " + System.IO.File.ReadAllText(node.Attributes[1].Value) + "<-----> ";
            }
            return _resultado;
        }

        /// <summary>
        /// Propósito: Copiar un archivo en un directorio.
        /// </summary>
        /// <param name="paths">Direcciones del archivo a copair y su destino</param>
        /// <param name="tipo">tipo de copy</param>
        /// <returns>Estado de la operación</returns>
        public bool cpy(string paths, bool tipo)
        {
            bool _resultado = false;
            XmlNode _directorio = _xmlMemoria.DocumentElement;
            string[] _paths = paths.Split(' ');
            string[] _path;

            if (tipo)
            {

                _path = _paths[0].Split('/');

                XmlNode _nodo = cpyGetNodo(_directorio, _path, 2);

                if (_nodo != null)
                {
                    _path = _paths[1].Split('/');
                    _resultado = insertarNodo(_directorio, _nodo, _path, false, 2);
                    if (_resultado)
                        return _resultado;
                    else
                        return _resultado;
                }
                else
                    return false;
            }
            else
            {
                string _dir = _paths[0];

                if (System.IO.File.Exists(_dir))
                {
                    XmlNode _nuevofile = _xmlMemoria.CreateNode(XmlNodeType.Element, "file", null);
                    XmlAttribute _nombre = _xmlMemoria.CreateAttribute("nombre");
                    XmlAttribute _url = _xmlMemoria.CreateAttribute("url");
                    XmlAttribute _descripcion = _xmlMemoria.CreateAttribute("descripcion");
                    _nombre.Value = System.IO.Path.GetFileName(_dir);
                    _url.Value = _dir;
                    _descripcion.Value = "FEX00";
                    _nuevofile.Attributes.Append(_nombre);
                    _nuevofile.Attributes.Append(_url);
                    _nuevofile.Attributes.Append(_descripcion);
                    _nuevofile.InnerText = "";

                    _path = _paths[1].Split('/');
                    _resultado = insertarNodo(_directorio, _nuevofile, _path, false, 2);
                    if (_resultado)
                        return _resultado;
                    else
                        return _resultado;
                     
                }
                else
                    return false;
            }
        }


        /// <summary>
        /// Propósito: Recorrer el xml en búsqueda del nodo especificado.
        /// </summary>
        /// <param name="nodo">Nodo actual</param>
        /// <param name="path">Ruta del directorio final</param>
        /// <param name="posicion">Posición en la ruta</param>
        /// <returns>Nodo del directorio final</returns>

        public XmlNode cpyGetNodo(XmlNode nodo, string[] path, int posicion)
        {
            foreach (XmlNode hijo in nodo.ChildNodes)
            {
                if ((hijo.Attributes[0].Value == path[posicion]))
                {
                    if (posicion + 1 != path.Length)
                    {
                        nodo = cpyGetNodo(hijo, path, posicion + 1);
                        break;
                    }
                    else if (posicion + 1 == path.Length)
                    {
                        nodo = hijo;
                        break;
                    }
                    else
                    {
                        nodo = null;
                        break;
                    }
                }
            }
            return nodo;
        }

        /// <summary>
        /// Propósito: Mover un archivo o directorio de ruta.
        /// </summary>
        /// <param name="paths">Direcciones de los archivos de origen y destino</param>
        /// <returns>Estado de la operación</returns>
        

        public bool mv(string paths)
        {
            bool _resultado = false;
            XmlNode _directorio = _xmlMemoria.DocumentElement;
            string[] _paths = paths.Split(' ');
            string[] _dir = _paths[0].Split('/');

            XmlNode _nodo = mvDeleteNodo(_directorio, _dir, 2);
            _nodo.Attributes[0].Value = _paths[2];

            if (_nodo != null)
            {
                _dir = _paths[1].Split('/');
                _resultado = insertarNodo(_directorio, _nodo, _dir, false, 2);

                return _resultado;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// Propósito: Recorrer el xml en búsqueda del nodo especificado.
        /// </summary>
        /// <param name="nodo">Nodo actual</param>
        /// <param name="path">Ruta del directorio final</param>
        /// <param name="posicion">Posición en la ruta</param>
        /// <returns>Nodo del directorio final</returns>

        public XmlNode mvDeleteNodo(XmlNode nodo, string[] path, int posicion)
        {
            foreach (XmlNode hijo in nodo.ChildNodes)
            {
                if ((hijo.Attributes[0].Value == path[posicion]))
                {
                    if (posicion + 1 != path.Length)
                    {
                        nodo = cpyGetNodo(hijo, path, posicion + 1);
                        break;
                    }
                    else if (posicion + 1 == path.Length)
                    {
                        nodo = hijo;
                        hijo.RemoveChild(hijo);
                        _xmlMemoria.Save(_path);
                        break;
                    }
                    else
                    {
                        nodo = null;
                        break;
                    }
                }
            }
            return nodo;
        }


        /// <summary>
        /// Propósito: Insertar un directorio o archivo en un directorio
        /// </summary>
        /// <param name="nodo">directorio raíz</param>
        /// <param name="dir">directorio a insertar</param>
        /// <param name="path">ruta en la que se inserta</param>
        /// <param name="estado">estado de la operación</param>
        /// <param name="posicion">posición dentro de la ruta</param>
        /// <returns>estado de la operación</returns>

        public bool insertarNodo(XmlNode nodo, XmlNode dir, string[] path, bool estado, int posicion)
        {

            foreach (XmlNode hijo in nodo.ChildNodes)
            {
                if ((hijo.Name == "dir") && (hijo.Attributes[0].Value == path[posicion]))
                {
                    if (posicion + 1 != path.Length)
                    {
                        estado = insertarNodo(hijo, dir, path, estado, posicion + 1);
                        break;
                    }
                    else if (posicion + 1 == path.Length)
                    {
                        hijo.AppendChild(dir);
                        _xmlMemoria.Save(_path);
                        estado = true;
                        break;
                    }
                    else
                    {
                        nodo = null;
                        break;
                    }
                }
            }

            return estado;
        }

        /// <summary>
        /// Propósito: Encontrar todas las rutas al archivo o directorio especificado.
        /// </summary>
        /// <param name="_nombre">nombre del archivo o directorio buscado</param>
        /// <returns>lista de rutas</returns>

        public List<string> find(string nombre, bool tipo)
        {
            List<string> _rutas = new List<string>();
            XmlNode _directorio = _xmlMemoria.DocumentElement;

            if (tipo)
                _rutas = findBusqueda(_directorio, "/root", _rutas, nombre);
            else
                _rutas = findAll(_directorio, "/root", _rutas, nombre);

            return _rutas;
        }

        /// <summary>
        /// Proósito: recorer el archivo xml en búsqueda de los archivo o directorios especificados.
        /// </summary>
        /// <param name="nodo">nodo actual</param>
        /// <param name="ruta">ruta actual</param>
        /// <param name="rutas">lista de rutas encontradas</param>
        /// <param name="nombre">nombre del archivo o directorio</param>


        public List<string> findBusqueda(XmlNode nodo, string ruta, List<string> rutas, string nombre)
        {
            foreach (XmlNode hijo in nodo.ChildNodes)
            {
                if (hijo.Attributes[0].Value == nombre)
                {
                    ruta = ruta + "/" + nombre;
                    rutas.Add(ruta);
                    
                }
                else
                {
                    if (hijo.Name == "dir")
                    {
                        ruta = ruta + "/" + hijo.Attributes[0].Value;
                        rutas = findBusqueda(hijo, ruta, rutas, nombre);
                    }
                }
            }

            return rutas;
        }

        public List<string> findAll(XmlNode nodo, string ruta, List<string> rutas, string extension)
        {
            foreach (XmlNode hijo in nodo.ChildNodes)
            {
                if (compararExtension(hijo.Attributes[0].Value, extension))
                {
                    ruta = ruta + "/" + hijo.Attributes[0].Value;
                    rutas.Add(ruta);

                }
                else
                {
                    if (hijo.Name == "dir")
                    {
                        ruta = ruta + "/" + hijo.Attributes[0].Value;
                        rutas = findAll(hijo, ruta, rutas, extension);
                    }
                }
            }

            return rutas;
        }

        public bool compararExtension(string nombre, string extension)
        {
            bool _resultado = false;
            int _tamaNom = nombre.Length;
            int _tamaEx = extension.Length;
            char[] _nombre = nombre.ToArray();
            char[] _extension = extension.ToArray();
            Array.Reverse(_nombre);
            Array.Reverse(_extension);

            for (int i = 0; i < _tamaEx; i++)
            {
                if (_nombre[i] != _extension[i])
                    break;
                if ((_nombre[i] == '.') && (_extension[i] == '.'))
                {
                    _resultado = true;
                    break;
                }
            }


            return _resultado;
        }

        /// <summary>
        /// Propósito: Agregar un archivo nuevo en el directorio donde nos encontramos.
        /// </summary>
        /// <param name="padre">Directorio Actual</param>
        /// <param name="nombre">Nombre del nuevo archivo</param>
        /// <param name="contenido">Contenido del nuevo archivo</param>
        /// <returns></returns>
        public bool File(string padre, string nombre, string contenido, string ruta)
        {
            XmlNode _directorio = _xmlMemoria.DocumentElement;
            if (_crearArchivo(_directorio, nombre, padre, contenido, false,ruta))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// Propósito: Verificar si existe un archivo con el nombre que queremos en el directorio actual,
        /// si no, Crear el archivo nuevo.
        /// </summary>
        /// <param name="nodo">Nodo actual</param>
        /// <param name="nombre">Nombre del nuevo archivo</param>
        /// <param name="padre">Directorio Actual</param>
        /// <param name="contenido">Contenido del nuevo archivo</param>
        /// <returns></returns>
        public bool _crearArchivo(XmlNode nodo, string nombre, string padre, string contenido, bool estado, string rutaAbsoluta)
        {
            //variables
            bool esta = false;
            XmlNode nodopadre = null;

            foreach (XmlNode hijo in nodo.ChildNodes)
            {
                if ((hijo.Name == "dir") && (hijo.Attributes[0].Value == padre))
                {
                    nodopadre = hijo;
                    try
                    {
                        foreach (XmlNode nodohijo in hijo.ChildNodes)
                        {
                            if ((nodohijo.Name == "file") && (nodohijo.Attributes[0].Value == nombre))
                            {

                                esta = true;
                                break;
                            }
                        }
                        if (!esta)
                        {
                            try
                            {
                                XmlNode _nuevoArch = _xmlMemoria.CreateNode(XmlNodeType.Element, "file", null);
                                //atributo nombre
                                XmlAttribute _atributo_nombre = _xmlMemoria.CreateAttribute("nombre");
                                _atributo_nombre.Value = nombre;
                                _nuevoArch.Attributes.Append(_atributo_nombre);
                                //atributo url
                                XmlAttribute _atributo_url = _xmlMemoria.CreateAttribute("url");
                                _atributo_url.Value = rutaAbsoluta;
                                _nuevoArch.Attributes.Append(_atributo_url);
                                //atributo descripcion
                                XmlAttribute _atributo_contenido = _xmlMemoria.CreateAttribute("descripcion");
                                _atributo_contenido.Value = contenido;
                                _nuevoArch.Attributes.Append(_atributo_contenido);

                                _nuevoArch.InnerText = "";
                                nodopadre.AppendChild(_nuevoArch);
                                _xmlMemoria.Save(_path);
                                estado = true;
                            }
                            catch (Exception ex)
                            {
                                throw ex;
                            }
                        }

                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                }
                else
                {
                    _crearArchivo(hijo, nombre, padre, contenido, estado,rutaAbsoluta);
                }

            }
            return estado;
        }

        /// <summary>
        /// Próposito: Devuelve el directorio actual
        /// </summary>
        /// <param name="ruta">Directorio actual</param>
        /// <returns></returns>
        public XmlNode arbol(string [] ruta)
        {
            estado = false;
            resultado = false;
            nuevo = null;
            XmlNode _direct = _xmlMemoria.DocumentElement;
            var i = 2;
            if ((ruta[1] == "root") && (ruta[ruta.Count()-1]=="root"))
            {
                return _direct;
            }
            else
            {
                return buscarruta(_direct, ruta,i);
            }
        }
        
        /// <summary>
        /// Próposito: Buscar con profundidad en nodo actual
        /// </summary>
        /// <param name="_directorio">Directorio conpleto del disco</param>
        /// <param name="ruta">ruta actual</param>
        /// <param name="puntero">indice para recorrer la ruta</param>
        /// <returns></returns>
        public XmlNode buscarruta(XmlNode _directorio,string [] ruta,int puntero)
        {
           
            if (puntero <= ruta.Count() - 1)
            {
                try
                {
                    foreach (XmlNode hijo in _directorio.ChildNodes)
                    {
                        if ((hijo.Name == "dir") && (hijo.Attributes[0].Value == ruta[puntero]))
                        {
                            puntero++;
                            buscarruta(hijo, ruta, puntero);
                            break;
                        }
                    }
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            else if (puntero == ruta.Count())
            {
                nuevo = _directorio;
                estado = true;
            }


            if(!estado)
                return null;
            else
            {
                return nuevo;
            }
            
        }
        
        public bool borrar(string nombre)
        {
            estado = false;
            nuevo = null;
            XmlNode _direct = _xmlMemoria.DocumentElement;
            bool _direct_final = buscarrutahijo(_direct,nombre);
           if (_direct_final)
           {
             return true;
           }
           else
           {
               return false;
           }
        }

        public bool buscarrutahijo(XmlNode _directorio,string nodo)
        {
            foreach (XmlNode hijo in _directorio.ChildNodes)
            {
                if ((hijo.Name == "dir") && (hijo.Attributes[0].Value == nodo))
                {
                    nuevo = hijo;
                    _directorio.RemoveChild(nuevo);
                    _xmlMemoria.Save(_path);
                    resultado = true;
                    return resultado;
                    break;
                }
                else
                {
                    buscarrutahijo(hijo, nodo);
                }
            }
            return resultado;
        }

        public bool borrararchivos(string nombre)
        {
            estado = false;
            nuevo = null;
            XmlNode _direct = _xmlMemoria.DocumentElement;
            bool _direct_final = buscarrutahijo2(_direct, nombre);
            if (_direct_final)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public bool buscarrutahijo2(XmlNode _directorio, string nodo)
        {
            foreach (XmlNode hijo in _directorio.ChildNodes)
            {
                if ((hijo.Name == "file") && (hijo.Attributes[0].Value == nodo))
                {
                    nuevo = hijo;
                    _directorio.RemoveChild(nuevo);
                    _xmlMemoria.Save(_path);
                    resultado = true;
                    return resultado;
                    break;
                }
                else
                {
                    buscarrutahijo2(hijo, nodo);
                }
            }
            return resultado;
        }
        
    }
}
